package cn.dduan.fool.thread.pool.executor;

import cn.dduan.fool.thread.pool.task.MyRunnable;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;

/**
 * 创建一个默认的线程池对象，里面的线程可重用，且在第一次使用时才创建
 * execute()：
 * 1、只能提交Runnable类型的任务，没有返回值
 * 2、execute方法提交的任务异常是直接抛出的
 * submit()：
 * 1、既能提交Runnable类型任务也能提交Callable类型任务，返回Future类型
 * 2、submit方法是是捕获了异常的，当调用FutureTask的get方法时，才会抛出异常
 * shutdown()：仅仅是不再接受新的任务，以前的任务还会继续执行
 * shutdownNow()：立刻关闭线程池，如果线程池中还有缓存的任务没有执行，则取消执行，并返回这些任务
 * @author dduan
 * @version 1.0
 * @date 2023/3/19
 */
public class MyNewCachedThreadPool {

    /**
     * newCachedThreadPool()方法
     *
     * @param
     * @return void
     * @author dduan
     * @version 1.0
     * @date 2023/3/19
     */
    public void create() {
        // 使用工厂类获取线程池对象
        ExecutorService es = Executors.newCachedThreadPool();

        for (int i = 0; i < 10; i++) {
            // 创建任务
            /*Runnable runnable = new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName());
                }
            };*/
            es.execute(new MyRunnable(i));
        }
    }

    /**
     * newCachedThreadPool(ThreadFactory threadFactory)方法
     *
     * @param
     * @return void
     * @author dduan
     * @version 1.0
     * @date 2023/3/19
     */
    public void createF() {
        // 使用工厂类获取线程池对象
        ExecutorService es = Executors.newCachedThreadPool(new ThreadFactory() {
            int n = 1;

            @Override
            public Thread newThread(Runnable r) {
                return new Thread(r, String.format("自定义的线程名称-%d", n++));
            }
        });

        for (int i = 0; i < 10; i++) {
            // 创建任务
            Runnable runnable = new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName());
                }
            };
            es.execute(runnable);
        }
    }

    public static void main(String[] args) {
        MyNewCachedThreadPool t = new MyNewCachedThreadPool();
        // t.create();
        t.createF();
    }
}
